home *** CD-ROM | disk | FTP | other *** search
/ Exame Informatica 140 / Exame Informatica 140.iso / Programas / WorldWind / World_Wind_1.4.0_RC2.exe / Shaders / clouds.fx next >
Encoding:
Text File  |  2006-12-18  |  11.5 KB  |  409 lines

  1. // Fluttering flag vertex shader
  2.  
  3. // These lines are just for EffectEdit:
  4. string XFile = "flag.x";   // model
  5. int    BCLR = 0xff000000;          // background colour
  6.  
  7. texture Tex0;
  8.  
  9. // transformations provided by the app as input:
  10. float4x4 World: WORLD;
  11. float4x4 View : VIEW;
  12. float4x4 Projection : PROJECTION;
  13. float4  horzTapOffs[16];        // Gauss blur horizontal texture coordinate offsets
  14. float4  vertTapOffs[16];        // Gauss blur vertical texture coordinate offsets
  15. float4    TexelWeight[16];
  16. float4  pixelSize;
  17. float2  texelSize;
  18. float    ExposureLevel;
  19. float screenWidth;
  20. float screenHeight;
  21.  
  22.  
  23. texture RenderMap;
  24. sampler RenderMapSampler = sampler_state
  25. {
  26.    Texture = <RenderMap>;
  27.    MinFilter = LINEAR;
  28.    MagFilter = LINEAR;
  29.    MipFilter = LINEAR;
  30.    AddressU  = Clamp;
  31.    AddressV  = Clamp;
  32. };
  33.  
  34. texture FullResMap;
  35. sampler FullResMapSampler = sampler_state
  36. {
  37.    Texture = <FullResMap>;
  38.    MinFilter = LINEAR;
  39.    MagFilter = LINEAR;
  40.    MipFilter = LINEAR;
  41.    AddressU  = Clamp;
  42.    AddressV  = Clamp;
  43. };
  44.  
  45. struct VS_OUTPUT
  46. {
  47.     float4 Pos : POSITION;
  48.     float2 Tex : TEXCOORD0;
  49. };
  50.  
  51. VS_OUTPUT VS(
  52.     float3 Pos : POSITION,
  53.     float2 Tex : TEXCOORD0)
  54. {
  55.     VS_OUTPUT Out = (VS_OUTPUT)0;
  56.  
  57.     float4x4 WorldView = mul(World, View);
  58.     
  59.     float3 P = mul(float4(Pos, 1), (float4x3)WorldView);
  60.     
  61.     // transform Position
  62.     Out.Pos = mul(float4(P, 1), Projection);
  63.     Out.Tex = Tex; 
  64.  
  65.     return Out;
  66. }
  67.  
  68. sampler Sampler = sampler_state
  69. {
  70.     Texture = (Tex0);
  71.     MipFilter = LINEAR;
  72.     MinFilter = LINEAR;
  73.     MagFilter = LINEAR;
  74. };
  75.  
  76. float4 PS(
  77.     float2 Tex : TEXCOORD0) : COLOR
  78. {
  79.     float4 f = tex2D(Sampler, Tex);
  80.     
  81.     //f.w = f.x;
  82.     
  83.     return f;
  84. }
  85.  
  86. // -------------------------------------------------------------
  87. // Output channels
  88. // -------------------------------------------------------------
  89. struct VS_OUTPUTScaleBuffer
  90. {
  91.     float4 Pos            : POSITION;
  92.     float2 Tex            : TEXCOORD0;    
  93. };
  94.  
  95. // -------------------------------------------------------------
  96. // vertex shader function (input channels)
  97. // -------------------------------------------------------------
  98. VS_OUTPUTScaleBuffer VSScaleBuffer(float4 Pos : POSITION)
  99. {
  100.     VS_OUTPUTScaleBuffer Out = (VS_OUTPUTScaleBuffer)0;        
  101.     Out.Pos.xy = Pos.xy + pixelSize.xy;
  102.     Out.Pos.z = 0.5f;
  103.     Out.Pos.w = 1.0f;
  104.     
  105.     Out.Tex = float2(0.5f, -0.5f) * Pos.xy + 0.5f.xx;    
  106.     
  107.     return Out;
  108. }
  109.  
  110. // -------------------------------------------------------------
  111. // Pixel Shader (input channels):output channel
  112. // -------------------------------------------------------------
  113. float4 PSScaleBuffer( float2 Tex :TEXCOORD0): COLOR                
  114. {
  115.     return tex2D(RenderMapSampler, Tex);
  116. }
  117.  
  118. // -------------------------------------------------------------
  119. // Output channels
  120. // -------------------------------------------------------------
  121. struct VS_OUTPUT_GaussX
  122. {
  123.     float4 Pos            : POSITION;
  124.     float2 Tap0            : TEXCOORD0;
  125.     float2 Tap1            : TEXCOORD1;    
  126.     float2 Tap2            : TEXCOORD2;
  127.     float2 Tap3            : TEXCOORD3;
  128.     float2 Tap1Neg        : TEXCOORD4;
  129.     float2 Tap2Neg        : TEXCOORD5;        
  130.     float2 Tap3Neg        : TEXCOORD6;        
  131. };
  132.  
  133. // -------------------------------------------------------------
  134. // vertex shader function (input channels)
  135. // -------------------------------------------------------------
  136. VS_OUTPUT_GaussX VSGaussX(float4 Pos      : POSITION)
  137. {
  138.     VS_OUTPUT_GaussX Out = (VS_OUTPUT_GaussX)0;        
  139.     Out.Pos.xy = Pos.xy + pixelSize.xy;
  140.     Out.Pos.z = 0.5f;
  141.     Out.Pos.w = 1.0f;
  142.     
  143.     float2 Tex = float2(0.5f, -0.5f) * Pos.xy + 0.5f.xx;    
  144.     
  145.     Out.Tap0 = Tex;
  146.     Out.Tap1 = Tex + horzTapOffs[1].xy;    
  147.     Out.Tap2 = Tex + horzTapOffs[2].xy;
  148.     Out.Tap3 = Tex + horzTapOffs[3].xy;
  149.     Out.Tap1Neg = Tex - horzTapOffs[1].xy;
  150.     Out.Tap2Neg = Tex - horzTapOffs[2].xy;            
  151.     Out.Tap3Neg = Tex - horzTapOffs[3].xy;            
  152.  
  153.     return Out;
  154. }
  155.  
  156.  
  157. // -------------------------------------------------------------
  158. // Pixel Shader (input channels):output channel
  159. // -------------------------------------------------------------
  160. float4 PSGaussX( float2 Tap0        : TEXCOORD0,
  161.                 float2 Tap1        : TEXCOORD1,    
  162.                 float2 Tap2        : TEXCOORD2,
  163.                 float2 Tap3        : TEXCOORD3,
  164.                 float2 Tap1Neg        : TEXCOORD4,
  165.                 float2 Tap2Neg        : TEXCOORD5,        
  166.                 float2 Tap3Neg        : TEXCOORD6) : COLOR0
  167. {
  168.     float4 Color[7];
  169.     float4 ColorSum = 0.0f;    
  170.  
  171.     // sample inner taps
  172.     Color[0]  = tex2D(RenderMapSampler, Tap0); 
  173.     Color[1]  = tex2D(RenderMapSampler, Tap1);
  174.     Color[2]  = tex2D(RenderMapSampler, Tap1Neg);
  175.     Color[3]  = tex2D(RenderMapSampler, Tap2); 
  176.     Color[4]  = tex2D(RenderMapSampler, Tap2Neg);
  177.     Color[5]  = tex2D(RenderMapSampler, Tap3);
  178.     Color[6]  = tex2D(RenderMapSampler, Tap3Neg); 
  179.     
  180.     ColorSum = Color[0] * TexelWeight[0];
  181.     ColorSum += Color[1] * TexelWeight[1];    
  182.     ColorSum += Color[2] * TexelWeight[1];
  183.     ColorSum += Color[3] * TexelWeight[2];
  184.     ColorSum += Color[4] * TexelWeight[2];            
  185.     ColorSum += Color[5] * TexelWeight[3];    
  186.     ColorSum += Color[6] * TexelWeight[3];    
  187.     
  188.     // compute texture coordinates for other taps
  189.     float2 Tap4 = Tap0 + horzTapOffs[4].xy;
  190.     float2 Tap5 = Tap0 + horzTapOffs[5].xy;
  191.     float2 Tap6 = Tap0 + horzTapOffs[6].xy;
  192.     float2 Tap4Neg = Tap0 - horzTapOffs[4].xy;
  193.     float2 Tap5Neg = Tap0 - horzTapOffs[5].xy;
  194.     float2 Tap6Neg = Tap0 - horzTapOffs[6].xy;
  195.     
  196.     // sample outer taps
  197.     Color[0]  = tex2D(RenderMapSampler, Tap4); 
  198.     Color[1]  = tex2D(RenderMapSampler, Tap4Neg);
  199.     Color[2]  = tex2D(RenderMapSampler, Tap5); 
  200.     Color[3]  = tex2D(RenderMapSampler, Tap5Neg); 
  201.     Color[4]  = tex2D(RenderMapSampler, Tap6); 
  202.     Color[5]  = tex2D(RenderMapSampler, Tap6Neg); 
  203.  
  204.     ColorSum += Color[0] * TexelWeight[4];
  205.     ColorSum += Color[1] * TexelWeight[4];
  206.     ColorSum += Color[2] * TexelWeight[5];
  207.     ColorSum += Color[3] * TexelWeight[5];
  208.     ColorSum += Color[4] * TexelWeight[6];
  209.     ColorSum += Color[5] * TexelWeight[6];    
  210.  
  211.     return ColorSum;                
  212. }
  213.  
  214. // -------------------------------------------------------------
  215. // Output channels
  216. // -------------------------------------------------------------
  217. struct VS_OUTPUT_GaussY
  218. {
  219.     float4 Pos        : POSITION;
  220.     float2 Tap0        : TEXCOORD0;
  221.     float2 Tap1        : TEXCOORD1;    
  222.     float2 Tap2        : TEXCOORD2;
  223.     float2 Tap3        : TEXCOORD3;
  224.     float2 Tap1Neg        : TEXCOORD4;
  225.     float2 Tap2Neg        : TEXCOORD5;        
  226.     float2 Tap3Neg        : TEXCOORD6;        
  227. };
  228.  
  229. // -------------------------------------------------------------
  230. // vertex shader function (input channels)
  231. // -------------------------------------------------------------
  232. VS_OUTPUT_GaussY VSGaussY(float4 Pos      : POSITION)
  233. {
  234.     VS_OUTPUT_GaussY Out = (VS_OUTPUT_GaussY)0;        
  235.     Out.Pos.xy = Pos.xy + pixelSize.xy;
  236.     Out.Pos.z = 0.5f;
  237.     Out.Pos.w = 1.0f;
  238.     
  239.     float2 Tex = float2(0.5f, -0.5f) * Pos.xy + 0.5f.xx;    
  240.  
  241.     Out.Tap0 = Tex;
  242.     Out.Tap1 = Tex + vertTapOffs[1].xy;    
  243.     Out.Tap2 = Tex + vertTapOffs[2].xy;
  244.     Out.Tap3 = Tex + vertTapOffs[3].xy;
  245.     Out.Tap1Neg = Tex - vertTapOffs[1].xy;
  246.     Out.Tap2Neg = Tex - vertTapOffs[2].xy;            
  247.     Out.Tap3Neg = Tex - vertTapOffs[3].xy;            
  248.  
  249.     return Out;
  250. }
  251.  
  252. // -------------------------------------------------------------
  253. // Pixel Shader (input channels):output channel
  254. // -------------------------------------------------------------
  255. float4 PSGaussY( float2 Tap0        : TEXCOORD0,
  256.                 float2 Tap1        : TEXCOORD1,    
  257.                 float2 Tap2        : TEXCOORD2,
  258.                 float2 Tap3        : TEXCOORD3,
  259.                 float2 Tap1Neg        : TEXCOORD4,
  260.                 float2 Tap2Neg        : TEXCOORD5,        
  261.                 float2 Tap3Neg        : TEXCOORD6) : COLOR0
  262. {
  263.     float4 Color[7];
  264.     float4 ColorSum = 0.0f;
  265.     
  266.     // sample inner taps
  267.     Color[0] = tex2D(RenderMapSampler, Tap0);
  268.     Color[1] = tex2D(RenderMapSampler, Tap1);
  269.     Color[2] = tex2D(RenderMapSampler, Tap1Neg);
  270.     Color[3] = tex2D(RenderMapSampler, Tap2);
  271.     Color[4] = tex2D(RenderMapSampler, Tap2Neg);
  272.     Color[5] = tex2D(RenderMapSampler, Tap3);
  273.     Color[6] = tex2D(RenderMapSampler, Tap3Neg);
  274.     
  275.     ColorSum = Color[0] * TexelWeight[0];
  276.     ColorSum += Color[1] * TexelWeight[1];    
  277.     ColorSum += Color[2] * TexelWeight[1];
  278.     ColorSum += Color[3] * TexelWeight[2];
  279.     ColorSum += Color[4] * TexelWeight[2];            
  280.     ColorSum += Color[5] * TexelWeight[3];    
  281.     ColorSum += Color[6] * TexelWeight[3];    
  282.  
  283.     // compute texture coordinates for other taps
  284.     float2 Tap4 = Tap0 + vertTapOffs[4].xy;
  285.     float2 Tap5 = Tap0 + vertTapOffs[5].xy;
  286.     float2 Tap6 = Tap0 + vertTapOffs[6].xy;
  287.     float2 Tap4Neg = Tap0 - vertTapOffs[4].xy;
  288.     float2 Tap5Neg = Tap0 - vertTapOffs[5].xy;
  289.     float2 Tap6Neg = Tap0 - vertTapOffs[6].xy;
  290.     
  291.     // sample outer taps
  292.     Color[0] = tex2D(RenderMapSampler, Tap4);
  293.     Color[1] = tex2D(RenderMapSampler, Tap4Neg);
  294.     Color[2] = tex2D(RenderMapSampler, Tap5);
  295.     Color[3] = tex2D(RenderMapSampler, Tap5Neg);
  296.     Color[4] = tex2D(RenderMapSampler, Tap6);
  297.     Color[5] = tex2D(RenderMapSampler, Tap6Neg);                                    
  298.  
  299.     ColorSum += Color[0] * TexelWeight[4];
  300.     ColorSum += Color[1] * TexelWeight[4];
  301.     ColorSum += Color[2] * TexelWeight[5];
  302.     ColorSum += Color[3] * TexelWeight[5];
  303.     ColorSum += Color[4] * TexelWeight[6];
  304.     ColorSum += Color[5] * TexelWeight[6];    
  305.     
  306.     return ColorSum;                
  307. }
  308.  
  309.  
  310. // -------------------------------------------------------------
  311. // Output channels
  312. // -------------------------------------------------------------
  313. struct VS_OUTPUTScreen
  314. {
  315.     float4 Pos            : POSITION;
  316.     float2 TopLeft        : TEXCOORD0;    
  317.     float2 TopRight        : TEXCOORD1;    
  318.     float2 BottomLeft    : TEXCOORD2;    
  319.     float2 BottomRight    : TEXCOORD3;    
  320. };
  321.  
  322. // -------------------------------------------------------------
  323. // vertex shader function (input channels)
  324. // -------------------------------------------------------------
  325. VS_OUTPUTScreen VSScreen(float4 Pos      : POSITION)
  326. {
  327.     VS_OUTPUTScreen Out = (VS_OUTPUTScreen)0;        
  328.     Out.Pos.xy = Pos.xy; // + pixelSize.xy;
  329.     Out.Pos.z = 0.5f;
  330.     Out.Pos.w = 1.0f;
  331.     
  332.     float2 Tex = float2(0.5f, -0.5f) * Pos.xy + 0.5f.xx;    
  333.     
  334.     const float2 oneZero   = float2(1.0f, 0.0f);
  335.  
  336.     Out.TopLeft     = Tex + oneZero.yy * texelSize;        // Top Left
  337.     Out.TopRight    = Tex + oneZero.xy * texelSize;        // Top Right
  338.     Out.BottomLeft  = Tex + oneZero.yx * texelSize;        // Bottom Left
  339.     Out.BottomRight = Tex + oneZero.xx * texelSize;        // Bottom Right
  340.     
  341.     return Out;
  342. }
  343.  
  344. // -------------------------------------------------------------
  345. // Pixel Shader (input channels):output channel
  346. // -------------------------------------------------------------
  347. float4 PSScreen(float2 Tex : TEXCOORD0) : COLOR0
  348. {
  349.     float4 FullScreenImage = tex2D(FullResMapSampler, Tex);
  350.     float4 BlurredImage = tex2D(RenderMapSampler, Tex);
  351.     
  352.     float4 color = lerp(FullScreenImage, BlurredImage, 0.4f);
  353.  
  354.     Tex -= 0.5f;                         // range -0.5..0.5    
  355.     float vignette = 1 - dot(Tex, Tex);    
  356.     
  357.     // multiply color with vignette^4
  358.     color = color * vignette * vignette * vignette * vignette;
  359.     
  360.     color *= ExposureLevel;            // apply simple exposure    
  361.     return pow(color, 0.55f);
  362. }
  363.  
  364. technique VSClouds
  365. {
  366.     pass P0
  367.     {
  368.         VertexShader = compile vs_1_1 VS();
  369.         PixelShader = compile ps_1_1 PS();
  370.     }
  371. }
  372.  
  373. technique ScaleBuffer
  374. {
  375.     pass P0
  376.     {
  377.         VertexShader = compile vs_1_1 VSScaleBuffer();
  378.         PixelShader  = compile ps_1_1 PSScaleBuffer();
  379.     }
  380. }
  381.  
  382. technique GaussX
  383. {
  384.     pass P0
  385.     {
  386.         VertexShader = compile vs_1_1 VSGaussX();
  387.         PixelShader  = compile ps_2_0 PSGaussX();
  388.     }
  389. }
  390.  
  391. technique GaussY
  392. {
  393.     pass P0
  394.     {
  395.         VertexShader = compile vs_1_1 VSGaussY();
  396.         PixelShader  = compile ps_2_0 PSGaussY();
  397.     }
  398. }
  399.  
  400.  
  401. technique Screenblit
  402. {
  403.     pass P0
  404.     {
  405.         VertexShader = compile vs_1_1 VSScreen();
  406.         PixelShader  = compile ps_2_0 PSScreen();
  407.     }
  408. }
  409.